```html
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Tomcat 请求处理流程深度解析 | 技术小馆</title>
    <link rel="stylesheet" href="https://cdn.staticfile.org/font-awesome/6.4.0/css/all.min.css">
    <link rel="stylesheet" href="https://cdn.staticfile.org/tailwindcss/2.2.19/tailwind.min.css">
    <link href="https://fonts.googleapis.com/css2?family=Noto+Serif+SC:wght@400;500;600;700&family=Noto+Sans+SC:wght@300;400;500;700&display=swap" rel="stylesheet">
    <script src="https://cdn.jsdelivr.net/npm/mermaid@latest/dist/mermaid.min.js"></script>
    <style>
        body {
            font-family: 'Noto Sans SC', Tahoma, Arial, Roboto, "Droid Sans", "Helvetica Neue", "Droid Sans Fallback", "Heiti SC", "Hiragino Sans GB", Simsun, sans-serif;
            line-height: 1.8;
            color: #333;
            background-color: #f9fafb;
        }
        h1, h2, h3, h4, h5, h6 {
            font-family: 'Noto Serif SC', serif;
            font-weight: 600;
            color: #111;
        }
        .hero-gradient {
            background: linear-gradient(135deg, #4f46e5 0%, #7c3aed 100%);
        }
        .card-hover:hover {
            transform: translateY(-5px);
            box-shadow: 0 20px 25px -5px rgba(0, 0, 0, 0.1), 0 10px 10px -5px rgba(0, 0, 0, 0.04);
        }
        .step-icon {
            width: 60px;
            height: 60px;
            background: linear-gradient(135deg, #3b82f6 0%, #6366f1 100%);
        }
        .dark-section {
            background: linear-gradient(135deg, #1e293b 0%, #0f172a 100%);
        }
        .mermaid {
            background-color: white;
            border-radius: 0.5rem;
            padding: 1.5rem;
            box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1);
        }
        .highlight {
            position: relative;
        }
        .highlight::before {
            content: '';
            position: absolute;
            left: -0.5rem;
            top: 0;
            height: 100%;
            width: 4px;
            background: linear-gradient(to bottom, #4f46e5, #7c3aed);
            border-radius: 4px;
        }
        a {
            color: #4f46e5;
            transition: all 0.2s;
        }
        a:hover {
            color: #7c3aed;
            text-decoration: underline;
        }
    </style>
</head>
<body class="antialiased">
    <!-- Hero Section -->
    <section class="hero-gradient text-white py-20 px-4 sm:px-6 lg:px-8">
        <div class="max-w-4xl mx-auto text-center">
            <div class="inline-flex items-center bg-white bg-opacity-20 rounded-full px-4 py-2 mb-6">
                <i class="fas fa-server mr-2"></i>
                <span class="font-medium">Java Web 技术</span>
            </div>
            <h1 class="text-4xl md:text-5xl font-bold mb-6 leading-tight">Tomcat 请求处理流程深度解析</h1>
            <p class="text-xl opacity-90 max-w-2xl mx-auto mb-8">探索 Java Web 服务器如何高效处理 HTTP 请求的完整生命周期</p>
            <div class="flex justify-center space-x-4">
                <a href="#process" class="bg-white text-indigo-600 hover:bg-indigo-50 px-6 py-3 rounded-lg font-medium transition-all duration-300 transform hover:-translate-y-1">
                    <i class="fas fa-play-circle mr-2"></i>开始探索
                </a>
                <a href="#visualization" class="bg-white bg-opacity-20 hover:bg-opacity-30 px-6 py-3 rounded-lg font-medium transition-all duration-300 transform hover:-translate-y-1">
                    <i class="fas fa-project-diagram mr-2"></i>可视化流程
                </a>
            </div>
        </div>
    </section>

    <!-- Main Content -->
    <div class="max-w-4xl mx-auto px-4 sm:px-6 lg:px-8 py-16">
        <!-- Introduction -->
        <div class="mb-16 highlight pl-8">
            <p class="text-lg text-gray-700 mb-6">Tomcat 是一个流行的 Java Servlet 容器和 Web 服务器，它负责接收 HTTP 请求、将请求交给相应的 Web 应用程序处理，并将响应返回给客户端。Tomcat 的请求处理过程是一个复杂的多阶段过程，涉及多个组件和步骤。</p>
        </div>

        <!-- Process Steps -->
        <div id="process" class="space-y-16">
            <!-- Step 1 -->
            <div class="flex flex-col md:flex-row gap-8">
                <div class="md:w-1/3">
                    <div class="step-icon rounded-full flex items-center justify-center text-white text-2xl mb-4 mx-auto">
                        <i class="fas fa-plug"></i>
                    </div>
                    <h2 class="text-2xl font-bold text-center md:text-left">1. 请求接收（Socket 接收和处理）</h2>
                    <p class="text-gray-600 mt-2 text-center md:text-left">网络连接建立与初始处理</p>
                </div>
                <div class="md:w-2/3 bg-white rounded-xl p-6 shadow-md card-hover transition-all duration-300">
                    <p>当客户端（如浏览器）向 Tomcat 发出 HTTP 请求时，请求首先到达服务器的网络端口（如默认的 8080 端口）。Tomcat 使用 <strong>Java NIO</strong> 或传统的 <strong>BIO</strong>（基于阻塞 I/O）机制来处理网络连接。</p>
                    
                    <div class="mt-6 space-y-4">
                        <div>
                            <h3 class="font-semibold text-lg text-indigo-600 flex items-center">
                                <i class="fas fa-link mr-2"></i>连接器（Connector）
                            </h3>
                            <p class="mt-2"><strong>Connector</strong> 是 Tomcat 中负责接收客户端连接的组件。Tomcat 的默认连接器实现是基于 NIO 的 <code class="bg-gray-100 px-2 py-1 rounded">org.apache.coyote.http11.Http11NioProtocol</code>。连接器监听指定的端口（如 8080），等待客户端的 TCP 连接请求。一旦接受到连接请求，连接器会创建一个 <code class="bg-gray-100 px-2 py-1 rounded">Socket</code> 对象来表示客户端的连接。</p>
                        </div>
                        
                        <div>
                            <h3 class="font-semibold text-lg text-indigo-600 flex items-center">
                                <i class="fas fa-cube mr-2"></i>创建请求和响应对象
                            </h3>
                            <p class="mt-2">对于每个新的连接，Connector 会创建两个对象：一个 <code class="bg-gray-100 px-2 py-1 rounded">Request</code> 对象用于封装 HTTP 请求数据，另一个 <code class="bg-gray-100 px-2 py-1 rounded">Response</code> 对象用于封装 HTTP 响应数据。这些对象是 Tomcat 的内部实现，提供了一个封装的 API 供后续组件使用。</p>
                        </div>
                    </div>
                </div>
            </div>

            <!-- Step 2 -->
            <div class="flex flex-col md:flex-row gap-8">
                <div class="md:w-1/3">
                    <div class="step-icon rounded-full flex items-center justify-center text-white text-2xl mb-4 mx-auto">
                        <i class="fas fa-code"></i>
                    </div>
                    <h2 class="text-2xl font-bold text-center md:text-left">2. 请求解析（HTTP 请求头和正文的解析）</h2>
                    <p class="text-gray-600 mt-2 text-center md:text-left">HTTP 协议解析与预处理</p>
                </div>
                <div class="md:w-2/3 bg-white rounded-xl p-6 shadow-md card-hover transition-all duration-300">
                    <p>连接器接收到 HTTP 请求后，会进行请求的解析。</p>
                    
                    <div class="mt-6 space-y-4">
                        <div>
                            <h3 class="font-semibold text-lg text-indigo-600 flex items-center">
                                <i class="fas fa-file-code mr-2"></i>HTTP 请求解析
                            </h3>
                            <p class="mt-2">Tomcat 使用 <code class="bg-gray-100 px-2 py-1 rounded">Http11Processor</code> 类解析 HTTP 请求。这个过程包括解析请求行、请求头、请求体等。解析后的数据会填充到 <code class="bg-gray-100 px-2 py-1 rounded">Request</code> 对象中，如请求方法（GET、POST）、URI、协议版本、请求头字段（如 Host、User-Agent）等。</p>
                        </div>
                        
                        <div>
                            <h3 class="font-semibold text-lg text-indigo-600 flex items-center">
                                <i class="fas fa-exchange-alt mr-2"></i>处理 Keep-Alive 和连接复用
                            </h3>
                            <p class="mt-2">Tomcat 会检查请求头中的 <code class="bg-gray-100 px-2 py-1 rounded">Connection</code> 字段来决定是否保持连接。对于 HTTP/1.1 默认是 Keep-Alive，意味着在同一个连接上可以发送多个请求。如果设置了 Keep-Alive，连接不会立即关闭，而是等待下一个请求。否则，响应返回后，连接将关闭。</p>
                        </div>
                    </div>
                </div>
            </div>

            <!-- Step 3 -->
            <div class="flex flex-col md:flex-row gap-8">
                <div class="md:w-1/3">
                    <div class="step-icon rounded-full flex items-center justify-center text-white text-2xl mb-4 mx-auto">
                        <i class="fas fa-route"></i>
                    </div>
                    <h2 class="text-2xl font-bold text-center md:text-left">3. 请求分派（Request Dispatching）</h2>
                    <p class="text-gray-600 mt-2 text-center md:text-left">请求路由与应用程序定位</p>
                </div>
                <div class="md:w-2/3 bg-white rounded-xl p-6 shadow-md card-hover transition-all duration-300">
                    <p>解析完请求后，Connector 将请求交给 <strong>Engine</strong> 处理。</p>
                    
                    <div class="mt-6 space-y-4">
                        <div>
                            <h3 class="font-semibold text-lg text-indigo-600 flex items-center">
                                <i class="fas fa-cogs mr-2"></i>服务（Service）和引擎（Engine）
                            </h3>
                            <p class="mt-2"><strong>Service</strong> 是 Tomcat 中的一个逻辑组件，负责将 Connector 和实际处理请求的 Engine 关联在一起。</p>
                            <p class="mt-2"><strong>Engine</strong> 是 Catalina 内核中的一个组件，负责将请求路由到正确的 Host（虚拟主机）。</p>
                        </div>
                        
                        <div>
                            <h3 class="font-semibold text-lg text-indigo-600 flex items-center">
                                <i class="fas fa-laptop-house mr-2"></i>虚拟主机（Host）
                            </h3>
                            <p class="mt-2">在 Engine 内部，可以配置多个虚拟主机（Host），每个虚拟主机对应一个域名或 IP 地址。Tomcat 使用请求头中的 Host 字段来决定请求应该路由到哪个虚拟主机。</p>
                        </div>
                        
                        <div>
                            <h3 class="font-semibold text-lg text-indigo-600 flex items-center">
                                <i class="fas fa-boxes mr-2"></i>上下文（Context）
                            </h3>
                            <p class="mt-2">每个 Host 下可以部署多个 Web 应用程序（Context）。Tomcat 使用请求的 URI（Uniform Resource Identifier）来决定请求应该路由到哪个 Web 应用。</p>
                            <p class="mt-2">例如，如果请求的 URI 是 <code class="bg-gray-100 px-2 py-1 rounded">/demo</code>，Tomcat 会将请求路由到名为 <code class="bg-gray-100 px-2 py-1 rounded">demo</code> 的应用程序上下文。</p>
                        </div>
                    </div>
                </div>
            </div>

            <!-- Step 4 -->
            <div class="flex flex-col md:flex-row gap-8">
                <div class="md:w-1/3">
                    <div class="step-icon rounded-full flex items-center justify-center text-white text-2xl mb-4 mx-auto">
                        <i class="fas fa-cog"></i>
                    </div>
                    <h2 class="text-2xl font-bold text-center md:text-left">4. 请求处理（Request Handling by Servlet）</h2>
                    <p class="text-gray-600 mt-2 text-center md:text-left">业务逻辑执行阶段</p>
                </div>
                <div class="md:w-2/3 bg-white rounded-xl p-6 shadow-md card-hover transition-all duration-300">
                    <p>在正确的 Context 中，Tomcat 进一步将请求交给具体的 Servlet 或 JSP 处理。</p>
                    
                    <div class="mt-6 space-y-4">
                        <div>
                            <h3 class="font-semibold text-lg text-indigo-600 flex items-center">
                                <i class="fas fa-filter mr-2"></i>过滤器链（Filter Chain）
                            </h3>
                            <p class="mt-2">在请求到达 Servlet 之前，Tomcat 首先会通过一系列的 <strong>过滤器（Filter）</strong>。过滤器是 Java EE 规范的一部分，可以在请求到达 Servlet 之前或响应返回客户端之前对请求或响应进行拦截和处理。常见的过滤器操作包括身份验证、日志记录、数据压缩等。</p>
                        </div>
                        
                        <div>
                            <h3 class="font-semibold text-lg text-indigo-600 flex items-center">
                                <i class="fas fa-code mr-2"></i>Servlet 处理
                            </h3>
                            <p class="mt-2">过滤器链处理完后，请求到达目标 <strong>Servlet</strong>。Servlet 是一个 Java 类，它实现了 <code class="bg-gray-100 px-2 py-1 rounded">javax.servlet.Servlet</code> 接口，负责生成动态内容。Tomcat 调用 Servlet 的 <code class="bg-gray-100 px-2 py-1 rounded">service</code> 方法（通常是 <code class="bg-gray-100 px-2 py-1 rounded">doGet</code>、<code class="bg-gray-100 px-2 py-1 rounded">doPost</code> 等方法），并传递 <code class="bg-gray-100 px-2 py-1 rounded">Request</code> 和 <code class="bg-gray-100 px-2 py-1 rounded">Response</code> 对象作为参数。Servlet 处理请求，执行应用逻辑，生成响应数据（如 HTML、JSON）。</p>
                        </div>
                    </div>
                </div>
            </div>

            <!-- Step 5 -->
            <div class="flex flex-col md:flex-row gap-8">
                <div class="md:w-1/3">
                    <div class="step-icon rounded-full flex items-center justify-center text-white text-2xl mb-4 mx-auto">
                        <i class="fas fa-reply"></i>
                    </div>
                    <h2 class="text-2xl font-bold text-center md:text-left">5. 生成响应（Response Generation）</h2>
                    <p class="text-gray-600 mt-2 text-center md:text-left">响应数据准备阶段</p>
                </div>
                <div class="md:w-2/3 bg-white rounded-xl p-6 shadow-md card-hover transition-all duration-300">
                    <p>Servlet 完成请求处理后，Tomcat 开始生成 HTTP 响应。</p>
                    
                    <div class="mt-6 space-y-4">
                        <div>
                            <h3 class="font-semibold text-lg text-indigo-600 flex items-center">
                                <i class="fas fa-file-export mr-2"></i>响应内容填充
                            </h3>
                            <p class="mt-2">Servlet 将处理结果写入 <code class="bg-gray-100 px-2 py-1 rounded">Response</code> 对象。这个过程包括设置响应状态码（如 200、404）、响应头（如 Content-Type、Content-Length）和响应体（实际的 HTML、JSON、文件数据等）。</p>
                        </div>
                        
                        <div>
                            <h3 class="font-semibold text-lg text-indigo-600 flex items-center">
                                <i class="fas fa-filter mr-2"></i>过滤器链的响应方向处理
                            </h3>
                            <p class="mt-2">在响应返回客户端之前，响应对象会再次通过过滤器链。这使得过滤器可以在响应返回前进行额外的处理，如数据压缩、日志记录等。</p>
                        </div>
                    </div>
                </div>
            </div>

            <!-- Step 6 -->
            <div class="flex flex-col md:flex-row gap-8">
                <div class="md:w-1/3">
                    <div class="step-icon rounded-full flex items-center justify-center text-white text-2xl mb-4 mx-auto">
                        <i class="fas fa-paper-plane"></i>
                    </div>
                    <h2 class="text-2xl font-bold text-center md:text-left">6. 发送响应（Sending Response to Client）</h2>
                    <p class="text-gray-600 mt-2 text-center md:text-left">响应回传阶段</p>
                </div>
                <div class="md:w-2/3 bg-white rounded-xl p-6 shadow-md card-hover transition-all duration-300">
                    <p>当响应准备好后，Tomcat 将其返回给客户端。</p>
                    
                    <div class="mt-6 space-y-4">
                        <div>
                            <h3 class="font-semibold text-lg text-indigo-600 flex items-center">
                                <i class="fas fa-network-wired mr-2"></i>序列化和发送响应
                            </h3>
                            <p class="mt-2"><code class="bg-gray-100 px-2 py-1 rounded">Http11Processor</code> 将 <code class="bg-gray-100 px-2 py-1 rounded">Response</code> 对象序列化为 HTTP 响应格式（包括状态行、响应头、响应体等），并通过 Socket 将其发送到客户端。</p>
                        </div>
                        
                        <div>
                            <h3 class="font-semibold text-lg text-indigo-600 flex items-center">
                                <i class="fas fa-link mr-2"></i>连接管理
                            </h3>
                            <p class="mt-2">如果请求使用的是 Keep-Alive 连接，则连接会被保持以等待新的请求。否则，Tomcat 会关闭 Socket 连接。</p>
                        </div>
                    </div>
                </div>
            </div>

            <!-- Step 7 -->
            <div class="flex flex-col md:flex-row gap-8">
                <div class="md:w-1/3">
                    <div class="step-icon rounded-full flex items-center justify-center text-white text-2xl mb-4 mx-auto">
                        <i class="fas fa-clipboard-check"></i>
                    </div>
                    <h2 class="text-2xl font-bold text-center md:text-left">7. 日志记录和连接关闭</h2>
                    <p class="text-gray-600 mt-2 text-center md:text-left">请求结束处理</p>
                </div>
                <div class="md:w-2/3 bg-white rounded-xl p-6 shadow-md card-hover transition-all duration-300">
                    <div class="space-y-4">
                        <div>
                            <h3 class="font-semibold text-lg text-indigo-600 flex items-center">
                                <i class="fas fa-clipboard-list mr-2"></i>请求日志记录
                            </h3>
                            <p class="mt-2">在整个请求处理结束后，Tomcat 会记录该请求的日志（如果启用了日志记录），包括请求的 URL、处理时间、返回状态等信息。</p>
                        </div>
                        
                        <div>
                            <h3 class="font-semibold text-lg text-indigo-600 flex items-center">
                                <i class="fas fa-recycle mr-2"></i>连接释放或复用
                            </h3>
                            <p class="mt-2">如果是长连接（Keep-Alive），Tomcat 会将连接返回到连接池等待新的请求；否则，关闭连接以释放资源。</p>
                        </div>
                    </div>
                </div>
            </div>
        </div>

        <!-- Visualization Section -->
        <div id="visualization" class="mt-24">
            <div class="text-center mb-12">
                <h2 class="text-3xl font-bold mb-4">Tomcat 请求处理流程可视化</h2>
                <p class="text-gray-600 max-w-2xl mx-auto">通过交互式流程图直观展示 Tomcat 处理 HTTP 请求的完整生命周期</p>
            </div>

            <div class="dark-section rounded-xl p-6 shadow-xl">
                <div class="mermaid">
                    flowchart TD
                    A[客户端发送HTTP请求] --> B[Tomcat Connector接收连接]
                    B --> C[创建Request/Response对象]
                    C --> D[解析HTTP请求]
                    D --> E{Keep-Alive?}
                    E -->|是| F[保持连接]
                    E -->|否| G[标记关闭连接]
                    F --> H[请求分派到Engine]
                    G --> H
                    H --> I[匹配虚拟主机Host]
                    I --> J[匹配上下文Context]
                    J --> K[通过过滤器链]
                    K --> L[Servlet处理请求]
                    L --> M[生成响应]
                    M --> N[反向过滤器链]
                    N --> O[序列化响应]
                    O --> P[发送响应到客户端]
                    P --> Q{连接状态}
                    Q -->|Keep-Alive| R[连接回到连接池]
                    Q -->|非Keep-Alive| S[关闭连接]
                    R --> T[等待新请求]
                    S --> U[记录日志]
                    U --> V[请求处理结束]
                </div>
            </div>
        </div>
    </div>

    <!-- Footer -->
    <footer class="bg-gray-900 text-gray-300 py-12">
        <div class="max-w-4xl mx-auto px-4 sm:px-6 lg:px-8">
            <div class="flex flex-col items-center">
                <h3 class="text-xl font-semibold mb-4">技术小馆</h3>
                <a href="http://www.yuque.com/jtostring" class="hover:text-white transition-colors duration-200 flex items-center">
                    <i class="fas fa-external-link-alt mr-2"></i> http://www.yuque.com/jtostring
                </a>
                <div class="mt-6 flex space-x-6">
                    <a href="#" class="hover:text-white transition-colors duration-200">
                        <i class="fab fa-github text-xl"></i>
                    </a>
                    <a href="#" class="hover:text-white transition-colors duration-200">
                        <i class="fab fa-twitter text-xl"></i>
                    </a>
                    <a href="#" class="hover:text-white transition-colors duration-200">
                        <i class="fab fa-linkedin text-xl"></i>
                    </a>
                </div>
            </div>
        </div>
    </footer>

    <script>
        mermaid.initialize({
            startOnLoad: true,
            theme: 'default',
            flowchart: {
                useMaxWidth: true,
                htmlLabels: true,
                curve: 'basis'
            }
        });
    </script>
</body>
</html>
```